home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / pluginy Firefox / 3006 / 3006.xpi / components / dhConvConfHandler.js < prev    next >
Encoding:
Text File  |  2010-01-15  |  10.3 KB  |  313 lines
  1. /******************************************************************************
  2.  *            Copyright (c) 2008-2009 Michel Gutierrez. All Rights Reserved.
  3.  ******************************************************************************/
  4.  
  5. /**
  6.  * Constants.
  7.  */
  8.  
  9. const NS_CONVCONF_HANDLER_CID = Components.ID("{2b554319-e7fb-420e-8f12-1bf88aa2848d}");
  10. const NS_CONVCONF_HANDLER_PROG_ID = "@downloadhelper.net/convconf-handler;1";
  11. const DHNS = "http://downloadhelper.net/1.0#";
  12.  
  13. var Util=null;
  14.  
  15. /**
  16. * Object constructor
  17. */
  18. function ConvConfHandler() {
  19.     this.localstore=Components.classes["@mozilla.org/rdf/datasource;1?name=local-store"]
  20.                                        .getService(Components.interfaces.nsIRDFDataSource);
  21.     this.promptService=Components.classes["@mozilla.org/embedcomp/prompt-service;1"]
  22.                                           .getService(Components.interfaces.nsIPromptService);
  23.     var uriLoader = Components.classes["@mozilla.org/uriloader;1"].getService(Components.interfaces.nsIURILoader);
  24.     uriLoader.registerContentListener(this);
  25. }
  26.  
  27. ConvConfHandler.prototype = {
  28.         get loadCookie() { return this.mLoadCookie; },
  29.         set loadCookie(newval) { return this.mLoadCookie=newval; },
  30.         get parentContentListener() { return this.mParentContentListener; },
  31.         set parentContentListener(newval) { return this.mParentContentListener=newval; }
  32. }
  33.  
  34. ConvConfHandler.prototype.canHandleContent = function( 
  35.     contentType, 
  36.     isContentPreferred, 
  37.     desiredContentType )  {
  38.  
  39.     //dump("[ConvConfHandler] canHandleContent contentType: "+contentType+"\n");
  40.  
  41.     if(contentType=="application/x-downloadhelper-convconf") 
  42.         return true;
  43.     else
  44.         return false;
  45.     
  46. }
  47.  
  48. ConvConfHandler.prototype.doContent = function( 
  49.     contentType , 
  50.     isContentPreferred , 
  51.     request , 
  52.     contentHandler ) {
  53.     
  54.     //dump("[ConvConfHandler] doContent contentType: "+contentType+"\n");
  55.  
  56.     if(contentType!="application/x-downloadhelper-convconf")
  57.         return false;
  58.         
  59.     function StreamListener(service) {
  60.         this.outputStream=null;
  61.         this.debugData=false;
  62.         this.service=service;
  63.     }
  64.  
  65.     StreamListener.prototype={
  66.         QueryInterface: function(iid) {
  67.             if (!iid.equals(Components.interfaces.nsISupports) && 
  68.                 !iid.equals(Components.interfaces.nsIStreamListener)) {
  69.                     throw Components.results.NS_ERROR_NO_INTERFACE;
  70.                 }
  71.             return this;
  72.         },
  73.         onStartRequest: function(request,context) {
  74.  
  75.             try {
  76.  
  77.             this.httpChannel=request.QueryInterface(Components.interfaces.nsIHttpChannel);
  78.             this.responseStatus=this.httpChannel.responseStatus;
  79.             this.responseStatusText=this.httpChannel.responseStatusText;
  80.             this.contentType=this.httpChannel.getResponseHeader("content-type");            
  81.             this.data="";
  82.             
  83.             //dump("[ConvConfHandler/StreamListener] onStartRequest response: "+
  84.             //    this.responseStatus+" "+this.responseStatusText+"\n");
  85.  
  86.             } catch(e) {
  87.                 dump("[ConvConfHandler/StreamListener] onStartRequest error: "+e+"\n");    
  88.             }
  89.  
  90.         },
  91.         onDataAvailable: function(request,context,inputStream,offset,count) {
  92.             //dump("[ConvConfHandler/StreamListener] onDataAvailable\n");    
  93.  
  94.             try {
  95.             
  96.             var sstream = Components.classes["@mozilla.org/intl/converter-input-stream;1"]
  97.                    .createInstance(Components.interfaces.nsIConverterInputStream);
  98.             sstream.init(inputStream, "utf-8", 256, 
  99.                 Components.interfaces.nsIConverterInputStream.DEFAULT_REPLACEMENT_CHARACTER);
  100.  
  101.             var str={};
  102.             var n=sstream.readString(128,str);
  103.             while(n>0) {
  104.                 this.data+=str.value;
  105.                 //dump("[ConvConfHandler/StreamListener] onDataAvailable read: "+str.value+"\n");    
  106.                 str={};
  107.                 n=sstream.readString(128,str);
  108.             }
  109.  
  110.             } catch(e) {
  111.                 dump("[ConvConfHandler/StreamListener] onDataAvailable error: "+e+"\n");    
  112.             }
  113.  
  114.         },
  115.         onStopRequest: function(request,context,nsresult) {
  116.             //dump("[ConvConfHandler/StreamListener] onStopRequest\n");
  117.  
  118.             try {
  119.  
  120.             if(this.responseStatus==200) {
  121.  
  122.                 //dump("[ConvConfHandler/StreamListener] parsing data: "+this.data+"\n");            
  123.                     
  124.                 var parser=Components.classes["@mozilla.org/xmlextras/domparser;1"].
  125.                     createInstance(Components.interfaces.nsIDOMParser);
  126.                 var doc=parser.parseFromString(this.data,"text/xml");
  127.                 if(doc!=null) {
  128.                     var confNodes=Util.xpGetNodes(doc.documentElement,"/conversion-configs/conversion-config",{});
  129.                     for(var i=0;i<confNodes.length;i++) {
  130.                         var confNode=confNodes[i];
  131.                         var confValue=Util.xpGetString(confNode,"value/text()");
  132.                         var confLabel=Util.xpGetString(confNode,"label/text()");
  133.                         //dump("=>"+confLabel+" = "+confValue+"\n");
  134.                         var gotConf=false;
  135.                         var confs=Util.getChildResourcesS(this.service.localstore,DHNS+"conv-confs",{});
  136.                         for(var i=0;i<confs.length;i++) {
  137.                             var confValue0=Util.getPropertyValueRS(this.service.localstore,confs[i],DHNS+"value");
  138.                             if(confValue0==confValue) {
  139.                                 gotConf=true;
  140.                                 var confLabel0=Util.getPropertyValueRS(this.service.localstore,confs[i],DHNS+"label");
  141.                                 if(confLabel0==confLabel) {
  142.                                     this.service.promptService.alert(null,Util.getText("title.conv-conf-handler"),
  143.                                             Util.getFText("message.conv-conf.already-exist",[confLabel],1));
  144.                                 } else {
  145.                                     var r=this.service.promptService.confirm(null,Util.getText("title.conv-conf-handler"),
  146.                                             Util.getFText("message.conv-conf.rename",[confLabel,confLabel0],2));
  147.                                     if(r) {
  148.                                         Util.setPropertyValueRS(this.service.localstore,confs[i],DHNS+"label",confLabel);
  149.                                     }
  150.                                 }
  151.                             }
  152.                         }
  153.                         if(gotConf==false) {
  154.                             var r=this.service.promptService.confirm(null,Util.getText("title.conv-conf-handler"),
  155.                                     Util.getFText("message.conv-conf.create",[confLabel],1));
  156.                             if(r) {
  157.                                 var conf=Util.createNodeSR(this.service.localstore,DHNS+"conv-confs",null);
  158.                                 Util.setPropertyValueRS(this.service.localstore,conf,DHNS+"label",confLabel);
  159.                                 Util.setPropertyValueRS(this.service.localstore,conf,DHNS+"value",confValue);
  160.                             }
  161.                         }
  162.                     }
  163.                 } else {
  164.                     dump("[ConvConfHandler/StreamListener] invalid convconf file: "+this.data+"\n");
  165.                 }
  166.             }
  167.             
  168.             } catch(e) {
  169.                 dump("[ConvConfHandler/StreamListener] onStopRequest error: "+e+"\n");
  170.             }
  171.  
  172.         }
  173.     }
  174.     
  175.     try {
  176.         contentHandler.value=new StreamListener(this);
  177.     } catch(e) {
  178.         dump("[ConvConfHandler] openAsync error: "+e+"\n");    
  179.     }
  180.         
  181.     return false;
  182. }
  183.  
  184. ConvConfHandler.prototype.isPreferred = function( 
  185.     contentType , 
  186.     desiredContentType ) {
  187.  
  188.     dump("[ConvConfHandler] isPreferred contentType: "+contentType+"\n");
  189.  
  190.     if(contentType=="application/x-downloadhelper-convconf") 
  191.         return true;
  192.     else
  193.         return false;
  194.  
  195. }
  196.  
  197.  
  198. ConvConfHandler.prototype.onStartURIOpen = function( URI ) {
  199.  
  200.     //dump("[ConvConfHandler] onStartURIOpen: "+URI.spec+"\n");
  201.  
  202.     return false;
  203. }
  204.  
  205. ConvConfHandler.prototype.GetWeakReference = function( ) {
  206.  
  207.     //dump("[ConvConfHandler] GetWeakReference\n");
  208.  
  209.     return this;
  210. }
  211.  
  212.  
  213. ConvConfHandler.prototype.QueryInterface = function(iid) {
  214.     //dump("[ConvConfHandler] QueryInterface("+iid+")\n");
  215.     if(
  216.         iid.equals(Components.interfaces.nsISupports)==false &&
  217.         !iid.equals(Components.interfaces.nsIURIContentListener) &&
  218.         !iid.equals(Components.interfaces.nsISupportsWeakReference)
  219.     ) {
  220.             throw Components.results.NS_ERROR_NO_INTERFACE;
  221.         }
  222.     return this;
  223. }
  224.  
  225. var vConvConfHandlerModule = {
  226.     firstTime: true,
  227.     
  228.     /*
  229.      * RegisterSelf is called at registration time (component installation
  230.      * or the only-until-release startup autoregistration) and is responsible
  231.      * for notifying the component manager of all components implemented in
  232.      * this module.  The fileSpec, location and type parameters are mostly
  233.      * opaque, and should be passed on to the registerComponent call
  234.      * unmolested.
  235.      */
  236.     registerSelf: function (compMgr, fileSpec, location, type) {
  237.  
  238.         if (this.firstTime) {
  239.             this.firstTime = false;
  240.             throw Components.results.NS_ERROR_FACTORY_REGISTER_AGAIN;
  241.         }
  242.         compMgr = compMgr.QueryInterface(Components.interfaces.nsIComponentRegistrar);
  243.         compMgr.registerFactoryLocation(NS_CONVCONF_HANDLER_CID,
  244.                                         "ConvConfHandler",
  245.                                         NS_CONVCONF_HANDLER_PROG_ID, 
  246.                                         fileSpec,
  247.                                         location,
  248.                                         type);
  249.     },
  250.  
  251.     unregisterSelf: function(compMgr, fileSpec, location) {
  252.         compMgr = compMgr.QueryInterface(Components.interfaces.nsIComponentRegistrar);
  253.         compMgr.unregisterFactoryLocation(NS_DH_CONVCONF_HANDLER_CID, fileSpec);
  254.     },
  255.  
  256.     /*
  257.      * The GetClassObject method is responsible for producing Factory and
  258.      * SingletonFactory objects (the latter are specialized for services).
  259.      */
  260.     getClassObject: function (compMgr, cid, iid) {
  261.         if (!cid.equals(NS_CONVCONF_HANDLER_CID)) {
  262.             throw Components.results.NS_ERROR_NO_INTERFACE;
  263.         }
  264.  
  265.         if (!iid.equals(Components.interfaces.nsIFactory)) {
  266.             throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
  267.         }
  268.  
  269.         return this.vConvConfHandlerFactory;
  270.     },
  271.  
  272.     /* factory object */
  273.     vConvConfHandlerFactory: {
  274.         /*
  275.          * Construct an instance of the interface specified by iid, possibly
  276.          * aggregating it with the provided outer.  (If you don't know what
  277.          * aggregation is all about, you don't need to.  It reduces even the
  278.          * mightiest of XPCOM warriors to snivelling cowards.)
  279.          */
  280.         createInstance: function (outer, iid) {
  281.             if (outer != null) {
  282.                 throw Components.results.NS_ERROR_NO_AGGREGATION;
  283.             }
  284.     
  285.             if(Util==null) 
  286.                 Util=Components.classes["@downloadhelper.net/util-service;1"]
  287.                     .getService(Components.interfaces.dhIUtilService);
  288.  
  289.             return new ConvConfHandler().QueryInterface(iid);
  290.         }
  291.     },
  292.  
  293.     /*
  294.      * The canUnload method signals that the component is about to be unloaded.
  295.      * C++ components can return false to indicate that they don't wish to be
  296.      * unloaded, but the return value from JS components' canUnload is ignored:
  297.      * mark-and-sweep will keep everything around until it's no longer in use,
  298.      * making unconditional ``unload'' safe.
  299.      *
  300.      * You still need to provide a (likely useless) canUnload method, though:
  301.      * it's part of the nsIModule interface contract, and the JS loader _will_
  302.      * call it.
  303.      */
  304.     canUnload: function(compMgr) {
  305.         return true;
  306.     }
  307. };
  308.  
  309. function NSGetModule(compMgr, fileSpec) {
  310.     return vConvConfHandlerModule;
  311. }
  312.  
  313.